Express.js એપ્લિકેશન્સમાં ટાઈપસ્ક્રીપ્ટ મિડલવેરને સમજવા અને લાગુ કરવા માટેની એક વ્યાપક માર્ગદર્શિકા. મજબૂત અને જાળવી શકાય તેવા કોડ માટે અદ્યતન પ્રકારના દાખલાઓ શોધો.
ટાઈપસ્ક્રીપ્ટ મિડલવેર: એક્સપ્રેસ મિડલવેર ટાઈપ પેટર્નની નિપુણતા
Express.js, એક મિનિમાલિસ્ટ અને લવચીક Node.js વેબ એપ્લિકેશન ફ્રેમવર્ક, વિકાસકર્તાઓને મજબૂત અને સ્કેલેબલ API અને વેબ એપ્લિકેશન બનાવવા દે છે. ટાઈપસ્ક્રીપ્ટ સ્ટેટિક ટાઈપિંગ ઉમેરીને, કોડની જાળવણીક્ષમતા સુધારીને અને શરૂઆતમાં ભૂલો પકડીને એક્સપ્રેસને વધારે છે. મિડલવેર ફંક્શન એક્સપ્રેસનો એક આધારસ્તંભ છે, જે તમને રૂટ હેન્ડલર્સ સુધી પહોંચે તે પહેલાં વિનંતીઓને રોકવા અને પ્રક્રિયા કરવા સક્ષમ બનાવે છે. આ લેખ એક્સપ્રેસ મિડલવેરને વ્યાખ્યાયિત કરવા અને તેનો ઉપયોગ કરવા માટેના અદ્યતન ટાઈપસ્ક્રીપ્ટ પ્રકારના દાખલાઓ, ટાઈપ સલામતી અને કોડ સ્પષ્ટતા વધારવા વિશે ચર્ચા કરે છે.
એક્સપ્રેસ મિડલવેરને સમજવું
મિડલવેર ફંક્શન્સ એવા ફંક્શન્સ છે જે વિનંતી ઑબ્જેક્ટ (req), રિસ્પોન્સ ઑબ્જેક્ટ (res), અને એપ્લિકેશનના વિનંતી-પ્રતિસાદ ચક્રમાં આગામી મિડલવેર ફંક્શન સુધી પહોંચ ધરાવે છે. મિડલવેર ફંક્શન્સ નીચેના કાર્યો કરી શકે છે:
- કોઈપણ કોડ એક્ઝિક્યુટ કરો.
- વિનંતી અને પ્રતિસાદ ઑબ્જેક્ટમાં ફેરફારો કરો.
- વિનંતી-પ્રતિસાદ ચક્ર સમાપ્ત કરો.
- સ્ટેકમાં આગામી મિડલવેર ફંક્શનને કૉલ કરો.
મિડલવેર ફંક્શન્સ એક્સપ્રેસ એપ્લિકેશનમાં ઉમેરવામાં આવે તે પ્રમાણે ક્રમશઃ એક્ઝિક્યુટ થાય છે. મિડલવેર માટેના સામાન્ય ઉપયોગના કિસ્સાઓમાં શામેલ છે:
- વિનંતીઓનું લોગીંગ.
- વપરાશકર્તાઓને પ્રમાણિત કરવા.
- સંસાધનોની ઍક્સેસને અધિકૃત કરવી.
- વિનંતી ડેટાને માન્ય કરવો.
- ભૂલોનું સંચાલન.
મૂળભૂત ટાઈપસ્ક્રીપ્ટ મિડલવેર
મૂળભૂત ટાઈપસ્ક્રીપ્ટ એક્સપ્રેસ એપ્લિકેશનમાં, એક મિડલવેર ફંક્શન આના જેવું દેખાઈ શકે છે:
import { Request, Response, NextFunction } from 'express';
function loggerMiddleware(req: Request, res: Response, next: NextFunction) {
console.log(`Request: ${req.method} ${req.url}`);
next();
}
export default loggerMiddleware;
આ સરળ મિડલવેર કન્સોલ પર વિનંતી પદ્ધતિ અને URL લોગ કરે છે. ચાલો ટાઈપ એનોટેશન્સને વિગતવાર સમજીએ:
Request: એક્સપ્રેસ વિનંતી ઑબ્જેક્ટનું પ્રતિનિધિત્વ કરે છે.Response: એક્સપ્રેસ પ્રતિસાદ ઑબ્જેક્ટનું પ્રતિનિધિત્વ કરે છે.NextFunction: એક ફંક્શન જે, જ્યારે બોલાવવામાં આવે છે, ત્યારે સ્ટેકમાં આગામી મિડલવેરને એક્ઝિક્યુટ કરે છે.
તમે તમારી એક્સપ્રેસ એપ્લિકેશનમાં આ મિડલવેરનો ઉપયોગ આ રીતે કરી શકો છો:
import express from 'express';
import loggerMiddleware from './middleware/loggerMiddleware';
const app = express();
const port = 3000;
app.use(loggerMiddleware);
app.get('/', (req, res) => {
res.send('Hello, world!');
});
app.listen(port, () => {
console.log(`Server listening on port ${port}`);
});
મિડલવેર માટે અદ્યતન ટાઈપ પેટર્ન
જ્યારે મૂળભૂત મિડલવેર ઉદાહરણ કાર્યાત્મક છે, તે વધુ જટિલ પરિસ્થિતિઓ માટે લવચીકતા અને ટાઈપ સલામતીનો અભાવ ધરાવે છે. ચાલો ટાઈપસ્ક્રીપ્ટ સાથે મિડલવેર વિકાસને વધારતા અદ્યતન ટાઈપ પેટર્નનું અન્વેષણ કરીએ.
1. કસ્ટમ વિનંતી/પ્રતિસાદ પ્રકારો
ઘણીવાર, તમારે કસ્ટમ ગુણધર્મો સાથે Request અથવા Response ઑબ્જેક્ટને વિસ્તૃત કરવાની જરૂર પડશે. ઉદાહરણ તરીકે, પ્રમાણીકરણ પછી, તમે Request ઑબ્જેક્ટમાં user ગુણધર્મ ઉમેરવા માંગી શકો છો. ટાઈપસ્ક્રીપ્ટ તમને ડિક્લેરેશન મર્જિંગનો ઉપયોગ કરીને હાલના પ્રકારોને વધારવાની મંજૂરી આપે છે.
// src/types/express/index.d.ts
import { Request as ExpressRequest } from 'express';
declare global {
namespace Express {
interface Request {
user?: {
id: string;
email: string;
// ... other user properties
};
}
}
}
export {}; // This is needed to make the file a module
આ ઉદાહરણમાં, અમે વૈકલ્પિક user ગુણધર્મ શામેલ કરવા માટે Express.Request ઇન્ટરફેસને વધારી રહ્યા છીએ. હવે, તમારા પ્રમાણીકરણ મિડલવેરમાં, તમે આ ગુણધર્મ ભરી શકો છો:
import { Request, Response, NextFunction } from 'express';
function authenticationMiddleware(req: Request, res: Response, next: NextFunction) {
// Simulate authentication logic
const userId = req.headers['x-user-id'] as string; // Or fetch from a token, etc.
if (userId) {
// In a real application, you would fetch the user from a database
req.user = {
id: userId,
email: `user${userId}@example.com`
};
next();
} else {
res.status(401).send('Unauthorized');
}
}
export default authenticationMiddleware;
અને તમારા રૂટ હેન્ડલર્સમાં, તમે req.user ગુણધર્મને સુરક્ષિત રીતે ઍક્સેસ કરી શકો છો:
import express from 'express';
import authenticationMiddleware from './middleware/authenticationMiddleware';
const app = express();
const port = 3000;
app.use(authenticationMiddleware);
app.get('/profile', (req: Request, res: Response) => {
if (req.user) {
res.send(`Hello, ${req.user.email}! Your user ID is ${req.user.id}`);
} else {
// This should never happen if the middleware is working correctly
res.status(500).send('Internal Server Error');
}
});
app.listen(port, () => {
console.log(`Server listening on port ${port}`);
});
2. મિડલવેર ફેક્ટરીઓ
મિડલવેર ફેક્ટરીઓ એવા ફંક્શન્સ છે જે મિડલવેર ફંક્શન્સ પરત કરે છે. જ્યારે તમારે ચોક્કસ વિકલ્પો અથવા નિર્ભરતાઓ સાથે મિડલવેરને ગોઠવવાની જરૂર હોય ત્યારે આ પેટર્ન ઉપયોગી છે. ઉદાહરણ તરીકે, લોગિંગ મિડલવેરનો વિચાર કરો જે ચોક્કસ ફાઇલમાં સંદેશાઓ લોગ કરે છે:
import { Request, Response, NextFunction } from 'express';
import fs from 'fs';
import path from 'path';
function createLoggingMiddleware(logFilePath: string) {
return (req: Request, res: Response, next: NextFunction) => {
const logMessage = `[${new Date().toISOString()}] Request: ${req.method} ${req.url}\n`;
fs.appendFile(logFilePath, logMessage, (err) => {
if (err) {
console.error('Error writing to log file:', err);
}
next();
});
};
}
export default createLoggingMiddleware;
તમે આ મિડલવેર ફેક્ટરીનો ઉપયોગ આ રીતે કરી શકો છો:
import express from 'express';
import createLoggingMiddleware from './middleware/loggingMiddleware';
const app = express();
const port = 3000;
const logFilePath = path.join(__dirname, 'logs', 'requests.log');
app.use(createLoggingMiddleware(logFilePath));
app.get('/', (req, res) => {
res.send('Hello, world!');
});
app.listen(port, () => {
console.log(`Server listening on port ${port}`);
});
3. અસુમેળ મિડલવેર
મિડલવેર ફંક્શન્સને ઘણીવાર અસુમેળ કામગીરીઓ કરવાની જરૂર પડે છે, જેમ કે ડેટાબેઝ ક્વેરીઝ અથવા API કૉલ્સ. અસુમેળ કામગીરીઓને યોગ્ય રીતે હેન્ડલ કરવા માટે, તમારે ખાતરી કરવી પડશે કે અસુમેળ કામગીરી પૂર્ણ થયા પછી next ફંક્શનને કૉલ કરવામાં આવે. તમે async/await અથવા પ્રોમિસનો ઉપયોગ કરીને આ પ્રાપ્ત કરી શકો છો.
import { Request, Response, NextFunction } from 'express';
async function asyncMiddleware(req: Request, res: Response, next: NextFunction) {
try {
// Simulate an asynchronous operation
await new Promise(resolve => setTimeout(resolve, 100));
console.log('Asynchronous operation completed');
next();
} catch (error) {
next(error); // Pass the error to the error handling middleware
}
}
export default asyncMiddleware;
મહત્વપૂર્ણ: તમારા અસુમેળ મિડલવેરની અંદર ભૂલોને હેન્ડલ કરવાનું યાદ રાખો અને next(error) નો ઉપયોગ કરીને તેમને ભૂલ હેન્ડલિંગ મિડલવેર પર મોકલો. આ સુનિશ્ચિત કરે છે કે ભૂલોને યોગ્ય રીતે હેન્ડલ કરવામાં આવે છે અને લોગ કરવામાં આવે છે.
4. ભૂલ હેન્ડલિંગ મિડલવેર
ભૂલ હેન્ડલિંગ મિડલવેર એ એક ખાસ પ્રકારનું મિડલવેર છે જે વિનંતી-પ્રતિસાદ ચક્ર દરમિયાન થતી ભૂલોને હેન્ડલ કરે છે. ભૂલ હેન્ડલિંગ મિડલવેર ફંક્શન્સમાં ચાર દલીલો હોય છે: err, req, res, અને next.
import { Request, Response, NextFunction } from 'express';
function errorHandler(err: any, req: Request, res: Response, next: NextFunction) {
console.error(err.stack);
res.status(500).send('Something went wrong!');
}
export default errorHandler;
તમારે અન્ય તમામ મિડલવેર અને રૂટ હેન્ડલર્સ પછી ભૂલ હેન્ડલિંગ મિડલવેર રજીસ્ટર કરવું આવશ્યક છે. એક્સપ્રેસ ચાર દલીલોની હાજરી દ્વારા ભૂલ-હેન્ડલિંગ મિડલવેરને ઓળખે છે.
import express from 'express';
import asyncMiddleware from './middleware/asyncMiddleware';
import errorHandler from './middleware/errorHandler';
const app = express();
const port = 3000;
app.use(asyncMiddleware);
app.get('/', (req, res) => {
throw new Error('Simulated error!'); // Simulate an error
});
app.use(errorHandler); // Error handling middleware MUST be registered last
app.listen(port, () => {
console.log(`Server listening on port ${port}`);
});
5. વિનંતી માન્યતા મિડલવેર
વિનંતી માન્યતા સુરક્ષિત અને વિશ્વસનીય API બનાવવાનો એક નિર્ણાયક પાસું છે. મિડલવેરનો ઉપયોગ આવનારા વિનંતી ડેટાને માન્ય કરવા અને તમારા રૂટ હેન્ડલર્સ સુધી પહોંચે તે પહેલાં તે ચોક્કસ માપદંડોને પૂર્ણ કરે છે તેની ખાતરી કરવા માટે થઈ શકે છે. joi અથવા express-validator જેવી લાઈબ્રેરીઓનો ઉપયોગ વિનંતી માન્યતા માટે થઈ શકે છે.
અહીં express-validator નો ઉપયોગ કરીને એક ઉદાહરણ છે:
import { Request, Response, NextFunction } from 'express';
import { body, validationResult } from 'express-validator';
const validateCreateUserRequest = [
body('email').isEmail().normalizeEmail(),
body('password').isLength({ min: 8 }),
(req: Request, res: Response, next: NextFunction) => {
const errors = validationResult(req);
if (!errors.isEmpty()) {
return res.status(400).json({ errors: errors.array() });
}
next();
}
];
export default validateCreateUserRequest;
આ મિડલવેર વિનંતી બોડીમાં email અને password ફીલ્ડ્સને માન્ય કરે છે. જો માન્યતા નિષ્ફળ જાય, તો તે ભૂલ સંદેશાઓના એરે સાથે 400 Bad Request પ્રતિસાદ પરત કરે છે. તમે તમારા રૂટ હેન્ડલર્સમાં આ મિડલવેરનો ઉપયોગ આ રીતે કરી શકો છો:
import express from 'express';
import validateCreateUserRequest from './middleware/validateCreateUserRequest';
const app = express();
const port = 3000;
app.post('/users', validateCreateUserRequest, (req, res) => {
// If validation passes, create the user
res.send('User created successfully!');
});
app.listen(port, () => {
console.log(`Server listening on port ${port}`);
});
6. મિડલવેર માટે ડિપેન્ડન્સી ઇન્જેક્શન
જ્યારે તમારા મિડલવેર ફંક્શન્સ બાહ્ય સેવાઓ અથવા ગોઠવણીઓ પર આધાર રાખે છે, ત્યારે ડિપેન્ડન્સી ઇન્જેક્શન પરીક્ષણક્ષમતા અને જાળવણીક્ષમતા સુધારવામાં મદદ કરી શકે છે. તમે tsyringe જેવા ડિપેન્ડન્સી ઇન્જેક્શન કન્ટેનરનો ઉપયોગ કરી શકો છો અથવા ફક્ત તમારી મિડલવેર ફેક્ટરીઓને દલીલો તરીકે નિર્ભરતાઓ પસાર કરી શકો છો.
અહીં ડિપેન્ડન્સી ઇન્જેક્શન સાથે મિડલવેર ફેક્ટરીનો ઉપયોગ કરીને એક ઉદાહરણ છે:
// src/services/UserService.ts
export class UserService {
async createUser(email: string, password: string): Promise {
// In a real application, you would save the user to a database
console.log(`Creating user with email: ${email} and password: ${password}`);
await new Promise(resolve => setTimeout(resolve, 500)); // Simulate a database operation
}
}
// src/middleware/createUserMiddleware.ts
import { Request, Response, NextFunction } from 'express';
import { UserService } from '../services/UserService';
function createCreateUserMiddleware(userService: UserService) {
return async (req: Request, res: Response, next: NextFunction) => {
try {
const { email, password } = req.body;
await userService.createUser(email, password);
res.status(201).send('User created successfully!');
} catch (error) {
next(error);
}
};
}
export default createCreateUserMiddleware;
// src/app.ts
import express from 'express';
import createCreateUserMiddleware from './middleware/createUserMiddleware';
import { UserService } from './services/UserService';
import errorHandler from './middleware/errorHandler';
const app = express();
const port = 3000;
app.use(express.json()); // Parse JSON request bodies
const userService = new UserService();
const createUserMiddleware = createCreateUserMiddleware(userService);
app.post('/users', createUserMiddleware);
app.use(errorHandler);
app.listen(port, () => {
console.log(`Server listening on port ${port}`);
});
ટાઈપસ્ક્રીપ્ટ મિડલવેર માટે શ્રેષ્ઠ પ્રથાઓ
- મિડલવેર ફંક્શન્સને નાના અને કેન્દ્રિત રાખો. દરેક મિડલવેર ફંક્શનની એક જ જવાબદારી હોવી જોઈએ.
- તમારા મિડલવેર ફંક્શન્સ માટે વર્ણનાત્મક નામોનો ઉપયોગ કરો. નામ સ્પષ્ટપણે દર્શાવવું જોઈએ કે મિડલવેર શું કરે છે.
- ભૂલોને યોગ્ય રીતે હેન્ડલ કરો. હંમેશા ભૂલોને પકડો અને
next(error)નો ઉપયોગ કરીને તેમને ભૂલ હેન્ડલિંગ મિડલવેર પર મોકલો. - ટાઈપ સલામતી વધારવા માટે કસ્ટમ વિનંતી/પ્રતિસાદ પ્રકારોનો ઉપયોગ કરો. જરૂરિયાત મુજબ
RequestઅનેResponseઇન્ટરફેસને કસ્ટમ ગુણધર્મો સાથે વધારો. - ચોક્કસ વિકલ્પો સાથે મિડલવેરને ગોઠવવા માટે મિડલવેર ફેક્ટરીઓનો ઉપયોગ કરો.
- તમારા મિડલવેર ફંક્શન્સનું દસ્તાવેજીકરણ કરો. મિડલવેર શું કરે છે અને તેનો ઉપયોગ કેવી રીતે કરવો જોઈએ તે સમજાવો.
- તમારા મિડલવેર ફંક્શન્સનું સંપૂર્ણ પરીક્ષણ કરો. તમારા મિડલવેર ફંક્શન્સ યોગ્ય રીતે કાર્ય કરી રહ્યા છે તેની ખાતરી કરવા માટે યુનિટ ટેસ્ટ લખો.
નિષ્કર્ષ
ટાઈપસ્ક્રીપ્ટ સ્ટેટિક ટાઈપિંગ ઉમેરીને, કોડની જાળવણીક્ષમતા સુધારીને અને શરૂઆતમાં ભૂલો પકડીને એક્સપ્રેસ મિડલવેરના વિકાસને નોંધપાત્ર રીતે વધારે છે. કસ્ટમ વિનંતી/પ્રતિસાદ પ્રકારો, મિડલવેર ફેક્ટરીઓ, અસુમેળ મિડલવેર, ભૂલ હેન્ડલિંગ મિડલવેર અને વિનંતી માન્યતા મિડલવેર જેવા અદ્યતન ટાઈપ પેટર્નની નિપુણતા દ્વારા, તમે મજબૂત, સ્કેલેબલ અને ટાઈપ-સુરક્ષિત એક્સપ્રેસ એપ્લિકેશન બનાવી શકો છો. તમારા મિડલવેર ફંક્શન્સને નાના, કેન્દ્રિત અને સુ-દસ્તાવેજીકૃત રાખવા માટે શ્રેષ્ઠ પ્રથાઓનું પાલન કરવાનું યાદ રાખો.